package com.fg.cloud.manager.service;

import java.io.IOException;
import java.io.Serializable;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import com.fg.cloud.common.CommonConstants.FilePath;
import com.fg.cloud.common.file.FileUtils;
import com.fg.cloud.common.PageUtils;
import com.fg.cloud.common.ServiceException;
import com.fg.cloud.manager.entry.BaseEntity;
import com.fg.cloud.manager.mapper.BaseMapper;

/**
 * @author ：
 * @date ： 2017年6月9日 下午2:11:30
 * @Desc ：基础实现service
 */
public abstract class BaseServiceImpl implements BaseService {

	@Value("${file_upload_path}")
	private String file_upload_path; // 物理路径
	@Value("${image_root}")
	private String image_root; // 网络地址

	private static final int MAX_FILE_SIZE = 5 * 1024 * 1024; // 文件不能超过5M

	protected abstract <T extends BaseEntity> BaseMapper getBaseMapper();

	/**
	 * 分页查询
	 * 
	 * @param param
	 *            参数
	 * @return
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	@Override
	public <T extends BaseEntity> PageUtils<T> selectPage(Map<String, Object> param) {
		PageUtils<T> page = new PageUtils(select(param), count(param));
		return page;
	}

	/**
	 * 查询功能，返回list
	 * 
	 * @param param
	 *            查询参数
	 * @return
	 */
	@Override
	public <T extends BaseEntity> List<T> select(Map<String, Object> param) {
		return getBaseMapper().select(param);
	}

	/**
	 * 获取记录数
	 * 
	 * @param param
	 *            参数
	 * @return
	 */
	@Override
	public long count(Map<String, Object> param) {
		Serializable count = getBaseMapper().count(param);
		if (count == null) {
			return 0L;
		} else {
			return Long.valueOf(count.toString());
		}
	}

	/**
	 * 删除操作
	 * 
	 * @param id
	 *            操作对象id
	 * @return
	 */
	@Override
	@Transactional
	public int delete(Long id) {
		return getBaseMapper().delete(id);
	}

	/**
	 * 插入记录
	 * 
	 * @param t
	 *            具体对象
	 * @return
	 */
	@Override
	@Transactional
	public <T extends BaseEntity> int insert(T t) {
		return getBaseMapper().insert(t);
	}

	/**
	 * 修改操作
	 * 
	 * @param t
	 *            处理对象
	 * @return
	 */
	@Override
	@Transactional
	public <T extends BaseEntity> int update(T t) {
		return getBaseMapper().update(t);
	}

	/**
	 * 获取特定对象
	 * 
	 * @param id
	 * @return
	 */
	@Override
	public <T extends BaseEntity> T find(long id) {
		return getBaseMapper().find(id);
	}

	/**
	 * 保存文件
	 * 
	 * @param pictureFile
	 *            文件
	 * @param strPath
	 *            文件前缀
	 * @return
	 * @throws IOException
	 */
	@Override
	public String saveFile(MultipartFile pictureFile, String strPath) throws IOException {
		// 原来的文件
		if (pictureFile != null && !pictureFile.isEmpty()) {
			if (pictureFile.getSize() > MAX_FILE_SIZE) { // 大于5M
				throw new ServiceException("文件大小不能超过5M！");
			}
			// 直接返回带域名的地址
			String filePath = FileUtils.saveFile(pictureFile.getInputStream(),
					file_upload_path + FilePath.SEPARATOR + strPath, pictureFile.getOriginalFilename(),
					pictureFile.getContentType());
			return image_root + FilePath.SEPARATOR + strPath + filePath;
		}
		return null;
	}

	/**
	 * 删除文件
	 * 
	 * @param webPath
	 *            文件web路径
	 * @return
	 */
	@Override
	public boolean deleteFile(String webPath) throws IOException {
		/* 配置文件网页路径前缀 */
		String httpPath = image_root;
		/* 配置文件物理路径前缀 */
		String realPath = file_upload_path;
		/* 文件所在物理路径 */
		String path = webPath.replace(httpPath, realPath);
		return FileUtils.deleteFile(path);
	}
	
	/**
	 * 删除符合指定字段key的数据
	 * @param key String
	 * @param values String[] 值
	 * @return boolean true:成功
	 */
	@Transactional
	public boolean deletes(String key, String[] values) {
		return getBaseMapper().deletes(key, values) > 0 ? true : false;
	}
	

	@Transactional
	public <T extends BaseEntity> boolean insertSelective(T t) {
		return getBaseMapper().insertSelective(t) > 0 ? true: false;
	}

	@Override
	@Transactional
	public <T extends BaseEntity> boolean updateByPrimaryKeySelective(T t) {
		return getBaseMapper().updateByPrimaryKeySelective(t) > 0 ? true: false;
	}
	
	
}
